MacTech 1 to 12/MacTech-vol-1-12.toast/Source/MacTech® Magazine/Volume 12 - 1996/12.11 Nov 96/DebuggingStarter Code/DebugTraps.c

C/C++ Source or Header | 1996-09-09 | 17.7 KB | 932 lines | [TEXT/CWIE]

/*________________________________________________________________________________
    DebugTraps.c: includes all general purpose debugging code.
________________________________________________________________________________*/

#include "Debug.h"

#include "DebugTrapsOff.h"


#if USE_DEBUG_TRAPS    // [

#include "DebugLeaks.h"

#define kHStatePurgeableMask    0x40
#define kHStateLockedMask        0x80
#define kHStateResourceMask        0x20

#define HStateIsPurgeable(hState)    ( ((hState) & kHStatePurgeableMask) != 0 )
#define HStateIsLocked(hState)        ( ((hState) & kHStateLockedMask) != 0 )
#define HStateIsResource(hState)    ( ((hState) & kHStateResourceMask) != 0 )


#if USE_DEBUG_LEAKS
    #define MaybeUnusedArg(x)    {/*nothing*/}
#else
    // eliminate "unused argument" complaints from CodeWarrior
    #define MaybeUnusedArg(x)        {(x)    = (x);}
#endif


/*________________________________________________________________________________
    Errors such as 'noErr' and 'memFullErr' are normal because they can occur
    in normal usage with no adverse consequences. Other errors, which indicate
    a bad handle, heap, etc are not normal.
________________________________________________________________________________*/
    static Boolean
MemErrIsNormal( OSErr    err)
    {
    return( IsntErr( err ) || err == memFullErr );
    }


    static void
AssertMemErrIsNormal( ConstStr255Param msg)
    {
    OSErr    err;

    err    = LMGetMemErr();
    if ( ! MemErrIsNormal( err ) )
        {
        AssertNoErr( err, msg);
        }
    }


#define HandleIsPurged(h)        ( IsNil( *(h) ) )

    static Boolean
HandleIsPurgeable( Handle    h)
    {
    char    hState;

    hState    = HGetState( h );

    return( HStateIsPurgeable( hState ) );
    }


    static Boolean
HandleIsLocked( Handle    h)
    {
    char    hState;
    #define kHStatePurgeableMask    0x40
    #define kHStateLockedMask        0x80

    hState    = HGetState( h );

    return( HStateIsLocked( hState ) );
    }


    static Boolean
HandleIsPurgeableAndNotLocked( Handle h )
    {
    return( HandleIsPurgeable(h) && ! HandleIsLocked( h ) );
    }


/*________________________________________________________________________________
    Fill memory with a byte pattern.  Obviously, this routine can be optimized.
________________________________________________________________________________*/
    static void
FillMemory(
    void    *buffer,
    UInt32    byteCount,
    Byte    fillChar)
    {
    char    *cur;
    UInt32    counter;

    cur        = (char *)buffer;
    counter    = byteCount;
    while ( counter-- != 0 )
        {
        *cur++    = fillChar;
        }
    }


    static void
FillWithGarbage(
    void    *ptr,
    UInt32    byteCount)
    {
    FillMemory( ptr, byteCount, 0xBB );
    }


    static Boolean
IsValidMemoryAllocationSize(Size    theSize)
    {
    // choose the highest value that you anticipate
    #define kMaxReasonableAllocation        (128 * 1024UL * 1024UL )

    return( theSize >= 0 && theSize <= kMaxReasonableAllocation );
    }


    static void
AssertValidMemoryAllocationSize(
    Size            byteCount,
    ConstStr255Param    msg)
    {
    if ( ! IsValidMemoryAllocationSize( byteCount ) )
        {
        DebugNum( msg, byteCount);
        }
    }


#if PRAGMA_MARK_SUPPORTED
#pragma mark -
#pragma mark --- Memory Manager ---
#endif


    pascal void
DebugTraps_DisposeHandle(Handle h)
    {
    UInt32    hSize;
    SInt8    hState;

    AssertHandleIsValid( h, "\pDebugTraps_DisposeHandle");
    DebugLeaks_DisposingHandle( h );
    DebugLeaks_ForgetHandle( h );

    hState    = HGetState( h );
    Assert( ! HStateIsResource( hState ),
        "\pDebugTraps_DisposeHandle: this Handle is a resource. Use ReleaseResource");

    // fill the handle with junk prior to disposing it
    hSize    = GetHandleSize( h );
    if ( MemError() == noErr )
        {
        FillWithGarbage( *h, hSize);
        }

    DisposeHandle( h );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_DisposeHandle");
    }


#define kMaxReasonableBlockMove        (64 * 1024UL * 1024UL )

    pascal void
DebugTraps_BlockMove(
    const void    *srcPtr,
    void        *destPtr,
    Size        byteCount)
    {
    const void    *sysZone;

    AssertAddressIsValid( srcPtr, "\pDebugTraps_BlockMove");
    AssertAddressIsValid( destPtr, "\pDebugTraps_BlockMove");

    Assert( byteCount >= 0, "\pDebugTraps_BlockMove: negative byte count");
    Assert( byteCount <= kMaxReasonableBlockMove, "\pDebugTraps_BlockMove: count is huge...is this correct?");

    sysZone    = SystemZone();
    Assert( srcPtr >= (void *)sysZone, "\pDebugTraps_BlockMove: srcPtr below system zone");
    Assert( destPtr >= (void *)sysZone, "\pDebugTraps_BlockMove: destPtr below system zone");


    BlockMove( srcPtr, destPtr, byteCount);
    }


    pascal void
DebugTraps_BlockMoveData(
    const void    *srcPtr,
    void        *destPtr,
    Size        byteCount)
    {
    const void    *sysZone;

    AssertAddressIsValid( srcPtr, "\pDebugTraps_BlockMoveData");
    AssertAddressIsValid( destPtr, "\pDebugTraps_BlockMoveData");

    Assert( byteCount >= 0, "\pDebugTraps_BlockMoveData: negative byte count");
    Assert( byteCount <= kMaxReasonableBlockMove, "\pDebugTraps_BlockMoveData: count is huge...is this correct?");

    sysZone    = SystemZone();
    Assert( srcPtr >= (void *)sysZone, "\pDebugTraps_BlockMoveData: srcPtr below system zone");
    Assert( destPtr >= (void *)sysZone, "\pDebugTraps_BlockMoveData: destPtr below system zone");


    BlockMoveData( srcPtr, destPtr, byteCount);
    }


    pascal Handle
DebugTraps_NewHandle(
    Size        byteCount,
    const char    *srcFileName)
    {
    Handle    h;

    Assert( byteCount >= 0, "\pDebugTraps_NewHandle: negative count");

    h    = NewHandle( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewHandle" );

    // byteCount is tested as well, because the memory manager has a bug that
    // causes it to succeed in creating a valid handle for small negative sizes.
    // this bug may be fixed in 7.5.3 update 3.0
    if ( IsntNil( h ) && byteCount > 0 && LMGetMemErr() == noErr )
        {
        FillWithGarbage( *h, byteCount);

        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( h, kLeaks_NewHandle, srcFileName);
        }

    return( h );
    }




    pascal Handle
DebugTraps_NewHandleClear(
    Size        byteCount,
    const char    *srcFileName)
    {
    Handle    h;

    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_NewHandleClear");

    h    = NewHandleClear( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewHandleClear" );

    if ( IsntNil( h ) )
    {
        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( h, kLeaks_NewHandleClear, srcFileName);
    }

    return( h );
    }

    pascal Handle
DebugTraps_NewHandleSys(
    Size        byteCount,
    const char    *srcFileName)
    {
    Handle    h;

    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_NewHandleSys");

    h    = NewHandleSys( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewHandleSys" );

    if ( IsntNil( h ) && LMGetMemErr() == noErr )
        {
        FillWithGarbage( *h, byteCount);

        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( h, kLeaks_NewHandleSys, srcFileName);
        }

    return( h );
    }


    pascal Handle
DebugTraps_NewHandleSysClear(
    Size        byteCount,
    const char    *srcFileName)
    {
    Handle    h;

    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_NewHandleSysClear");

    h    = NewHandleSysClear( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewHandleSysClear" );

    if ( IsntNil( h ) )
    {
        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( h, kLeaks_NewHandleSysClear, srcFileName);
    }

    return( h );
    }


    pascal Size
DebugTraps_GetHandleSize(Handle h )
    {
    Size    theSize;
    OSErr    err;

    AssertHandleIsValid( h, "\pDebugTraps_GetHandleSize");

    theSize    = GetHandleSize( h );

    err    = LMGetMemErr();
    if ( err == nilHandleErr && IsNil( *h ) )
        {
        // normal to get this on purged Handle
        }
    else
        {
        AssertNoErr( err, "\pDebugTraps_GetHandleSize");
        }

    return( theSize );
    }



    pascal OSErr
DebugTraps_PtrToHand(
    const void    *srcPtr,
    Handle        *dstHndl,
    long        size,
    const char    *srcFileName)
    {
    OSErr    err;

    AssertAddressIsValid( srcPtr, "\pDebugTraps_PtrToHand");
    AssertAddressIsValid( dstHndl, "\pDebugTraps_PtrToHand");
    Assert( IsValidMemoryAllocationSize( size ), "\pDebugTraps_PtrToHand");

    err    = PtrToHand( srcPtr, dstHndl, size);
    AssertNoErr( err, "\pDebugTraps_PtrToHand");

    if ( IsntErr( err ) && IsntNil( *dstHndl ) )
        {
        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( *dstHndl, kLeaks_PtrToHand, srcFileName);
        }

    return( err );
    }


    pascal Ptr
DebugTraps_NewPtr(
    Size        byteCount,
    const char    *srcFileName)
    {
    Ptr    p;

    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_NewPtr");

    p    = NewPtr( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewPtr" );

    if ( IsntNil( p ) && LMGetMemErr() == noErr )
        {
        FillWithGarbage( p, byteCount);

        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberPtr( p, kLeaks_NewPtr, srcFileName);
        }

    return( p );
    }


    pascal Ptr
DebugTraps_NewPtrClear(
    Size        byteCount,
    const char    *srcFileName)
    {
    Ptr    p;

    AssertValidMemoryAllocationSize( byteCount, "\pDebugTraps_NewPtrClear");

    p    = NewPtrClear( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewPtrClear" );

    if ( IsntNil( p ) )
    {
        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberPtr( p, kLeaks_NewPtrClear, srcFileName);
    }

    return( p );
    }


    pascal Ptr
DebugTraps_NewPtrSys(
    Size        byteCount,
    const char    *srcFileName)
    {
    Ptr    p;

    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_NewPtrSys");

    p    = NewPtrSys( byteCount );
    AssertMemErrIsNormal( "\pDebugTraps_NewPtrSys" );

    if ( IsntNil( p ) && LMGetMemErr() == noErr )
        {
        FillWithGarbage( p, byteCount);

        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberPtr( p, kLeaks_NewPtrSys, srcFileName);
        }

    return( p );
    }


    pascal Ptr
DebugTraps_NewPtrSysClear(
    Size        byteCount,
    const char    *srcFileName)
    {
    Ptr    p;

    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_NewPtrSysClear");

    p    = NewPtrSysClear( byteCount );

    AssertMemErrIsNormal( "\pDebugTraps_NewPtrSysClear" );

    if ( IsntNil( p ) )
    {
        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberPtr( p, kLeaks_NewPtrSysClear, srcFileName);
    }

    return( p );
    }


    pascal Size
DebugTraps_GetPtrSize(Ptr p)
    {
    Size    theSize;

    theSize    = GetPtrSize( p );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_GetPtrSize" );

    return( theSize );
    }


    pascal void
DebugTraps_SetPtrSize(
    Ptr        p,
    Size    newSize)
    {
    AssertValidMemoryAllocationSize( newSize, "\p DebugTraps_SetPtrSize");

    SetPtrSize( p, newSize);

    AssertMemErrIsNormal( "\pDebugTraps_SetPtrSize" );
    }


    pascal THz
DebugTraps_PtrZone(Ptr p)
    {
    THz    zone;

    zone    = PtrZone( p );
    AssertMemErrIsNormal( "\pDebugTraps_PtrZone" );

    return( zone );
    }


    pascal void
DebugTraps_DisposePtr(Ptr p)
    {
    UInt32    ptrSize;

    AssertAddressIsValidAlign2( p, "\pDebugTraps_DisposePtr");

    DebugLeaks_DisposingPtr( p );

    // fill the handle with junk prior to disposing it
    ptrSize    = GetPtrSize( p );
    if ( LMGetMemErr() == noErr )
        {
        FillWithGarbage( p, ptrSize);
        }

    DisposePtr( p );
    DebugLeaks_ForgetPtr( p );

    AssertNoErr( LMGetMemErr(), "\pDebugTraps_DisposePtr");
    }




    pascal void
DebugTraps_SetHandleSize(
    Handle    h,
    Size    newSize)
    {
    Size    oldSize;
    SInt8    hState;
    OSErr    err    = noErr;

    AssertValidMemoryAllocationSize( newSize, "\p DebugTraps_SetHandleSize");
    AssertHandleIsValid( h, "\pDebugTraps_SetHandleSize");

    hState    = DebugTraps_HGetState( h );
    Assert( (hState & kHStateLockedMask) == 0,
        "\pDebugTraps_SetHandleSize: changing size of locked Handle is a bug on System 8");

    oldSize    = GetHandleSize( h );

    SetHandleSize( h, newSize);
    err    = LMGetMemErr();
    AssertMemErrIsNormal( "\pDebugTraps_SetHandleSize" );

    // we should either have the correct size Handle or an error
    Assert( IsErr( err ) || GetHandleSize( h ) == newSize,
        "\pDebugTraps_SetHandleSize: inconsistent results");

    if ( (newSize > oldSize) && IsntErr( err )  )
        {
        FillWithGarbage( ((char *)*h) + oldSize, newSize - oldSize);
        }
    }


    pascal void
DebugTraps_ReallocateHandle(
    Handle    h,
    Size    byteCount)
    {
    AssertValidMemoryAllocationSize( byteCount, "\p DebugTraps_ReallocateHandle");
    AssertHandleIsValid( h, "\pDebugTraps_ReallocateHandle");

    ReallocateHandle( h, byteCount);

    if ( LMGetMemErr() == noErr )
        {
        FillWithGarbage( *h, byteCount);
        }
    else
        {
        AssertMemErrIsNormal( "\pDebugTraps_ReallocateHandle" );
        }
    }


    pascal void
DebugTraps_HLock(Handle h)
    {
    AssertHandleIsValid( h, "\pstdHLock");
    Assert( ! HandleIsPurged(h), "\pDebugTraps_HLock: locking purged Handle");

    HLock( h );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_HLock");
    }


    pascal void
DebugTraps_HUnlock(Handle h)
    {
    AssertHandleIsValid( h, "\pstdHUnlock");

    HUnlock( h );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_HUnlock");
    }


    pascal SInt8
DebugTraps_HGetState(Handle h)
    {
    SInt8    hState;
    OSErr    err;

    AssertHandleIsValid( h, "\pDebugTraps_HGetState");

    hState    = HGetState( h );

    err    = LMGetMemErr();
    if ( err == nilHandleErr && IsNil( *h ) )
        {
        // normal to get this on purged Handle
        }
    else
        {
        AssertNoErr( err, "\pDebugTraps_HGetState");
        }

    return( hState );
    }


    pascal void
DebugTraps_HSetState(
    Handle    h,
    SInt8    flags)
    {
    OSErr    err;

    AssertHandleIsValid( h, "\pDebugTraps_HSetState");

    HSetState( h, flags);

    err    = LMGetMemErr();
    if ( err == nilHandleErr && IsNil( *h ) )
        {
        // normal to get this on purged Handle
        }
    else
        {
        AssertNoErr( err, "\pDebugTraps_HSetState");
        }
    }


    pascal OSErr
DebugTraps_HandAndHand(
    Handle    hand1,
    Handle    hand2)
    {
    OSErr    err;

    AssertHandleIsValid( hand1, "\pDebugTraps_HandAndHand");
    AssertHandleIsValid( hand2, "\pDebugTraps_HandAndHand");
    Assert( ! HandleIsPurgeableAndNotLocked( hand1 ), "\pDebugTraps_HandAndHand: purgeable hand1");
    Assert( ! HandleIsPurgeableAndNotLocked( hand2 ), "\pDebugTraps_HandAndHand: purgeable hand2");

    err    = HandAndHand( hand1, hand2 );
    AssertMemErrIsNormal( "\pDebugTraps_HandAndHand" );

    return( err );
    }


    pascal OSErr
DebugTraps_HandToHand(
    Handle        *theHandlePtr,
    const char    *srcFileName)
    {
    OSErr    err;
    Handle    temp;

    AssertHandleIsValid( *theHandlePtr, "\pDebugTraps_HandToHand");
    Assert( ! HandleIsPurgeableAndNotLocked( *theHandlePtr ),
        "\pDebugTraps_HandToHand: attempt to duplicate purgeable Handle");

    temp    = *theHandlePtr;
    err    = HandToHand( theHandlePtr );
    AssertMemErrIsNormal( "\pDebugTraps_HandToHand" );

    if ( IsntErr( err ) )
    {
        Assert( GetHandleSize( temp ) == GetHandleSize( *theHandlePtr ),
            "\pDebugTraps_HandToHand: different size");

        Assert( temp != *theHandlePtr, "\pDebugTraps_HandToHand: handle the same");
        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( *theHandlePtr, kLeaks_HandToHand, srcFileName);
    }

    return( err );
    }


    pascal void
DebugTraps_HPurge(Handle h)
    {
    OSErr    err;

    AssertHandleIsValid( h, "\pDebugTraps_HPurge");

    HPurge( h );

    err    = LMGetMemErr();
    if ( err == nilHandleErr && IsNil( *h ) )
        {
        // normal to get error on purged Handle
        }
    else
        {
        AssertNoErr( err, "\pDebugTraps_HPurge");
        }
    }


    pascal void
DebugTraps_EmptyHandle(Handle    h)
    {
    OSErr    err;
    UInt32    hSize;

    AssertHandleIsValid( h, "\pDebugTraps_EmptyHandle");

    hSize    = GetHandleSize( h );
    if ( LMGetMemErr() == noErr )
        {
        Assert( IsntNil( *h ), "\pDebugTraps_EmptyHandle: master pointer is nil");
        FillWithGarbage( *h, hSize);
        }

    EmptyHandle( h );
    err    = LMGetMemErr();
    AssertNoErr( err, "\pDebugTraps_EmptyHandle");
    }


    pascal void
DebugTraps_HNoPurge(Handle h)
    {
    AssertHandleIsValid( h, "\pDebugTraps_HNoPurge");
    Assert( ! HandleIsPurged(h), "\pDebugTraps_HNoPurge: handle already purged");

    HNoPurge( h );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_HNoPurge");
    }


    pascal THz
DebugTraps_HandleZone(Handle h)
    {
    THz        zone;
    AssertHandleIsValid( h, "\pDebugTraps_HandleZone");

    zone    = HandleZone( h );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_HandleZone");
    Assert( IsntNil( zone ), "\pDebugTraps_HandleZone");

    return( zone );
    }


    pascal Handle
DebugTraps_RecoverHandle(Ptr p)
    {
    Handle    h;

    AssertAddressIsValidAlign2( p, "\pDebugTraps_RecoverHandle");

    h    = RecoverHandle( p );

    AssertNoErr( LMGetMemErr(), "\pDebugTraps_RecoverHandle");
    AssertHandleIsValid( h, "\pDebugTraps_RecoverHandle");

    return( h );
    }


    pascal Handle
DebugTraps_RecoverHandleSys(Ptr p)
    {
    Handle    h;

    AssertAddressIsValidAlign2( p, "\pDebugTraps_RecoverHandleSys");

    h    = RecoverHandleSys( p );

    AssertNoErr( LMGetMemErr(), "\pDebugTraps_RecoverHandleSys");
    AssertHandleIsValid( h, "\pDebugTraps_RecoverHandleSys");

    return( h );
    }


    pascal void
DebugTraps_SetZone(THz hz)
    {
    AssertAddressIsValidAlign4( hz, "\pDebugTraps_SetZone");

    SetZone( hz );
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_SetZone");
    }


    pascal THz
DebugTraps_GetZone()
    {
    THz    hz;

    hz    = GetZone();
    AssertNoErr( LMGetMemErr(), "\pDebugTraps_GetZone");

    return( hz );
    }


    pascal Handle
DebugTraps_TempNewHandle(
    Size        logicalSize,
    OSErr        *resultCode,
    const char    *srcFileName)
    {
    Handle    h;

    AssertValidMemoryAllocationSize( logicalSize, "\pDebugTraps_TempNewHandle");

    AssertAddressIsValidAlign2( resultCode, "\pDebugTraps_TempNewHandle");

    h    = TempNewHandle( logicalSize, resultCode);

    if ( ! MemErrIsNormal( *resultCode ) )
        {
        AssertNoErr( *resultCode, "\pDebugTraps_TempNewHandle");
        }

    if ( IsntNil( h ) && *resultCode == noErr )
        {
        FillWithGarbage( *h, logicalSize);

        MaybeUnusedArg( srcFileName );
        DebugLeaks_RememberHandle( h, kLeaks_TempNewHandle, srcFileName);
        }

    return( h );
    }


    pascal void
DebugTraps_TempDisposeHandle(
    Handle    h,
    OSErr    *err)
    {
    AssertHandleIsValid( h , "\p DebugTraps_TempDisposeHandle");

    TempDisposeHandle( h, err);
    AssertNoErr( *err, "\p DebugTraps_TempDisposeHandle");

    DebugLeaks_ForgetHandle( h );
    }


    pascal void
DebugTraps_MoveHHi(Handle h)
    {
    AssertHandleIsValid( h , "\p DebugTraps_MoveHHi");

    MoveHHi( h );

    AssertNoErr( LMGetMemErr(), "\p DebugTraps_MoveHHi");
    }


    pascal OSErr
DebugTraps_PtrAndHand(
    const void    *ptr,
    Handle        hand,
    long        size)
    {
    OSErr    err;

    AssertHandleIsValid( hand , "\p DebugTraps_PtrAndHand");
    AssertAddressIsValid( ptr , "\p DebugTraps_PtrAndHand");
    AssertValidMemoryAllocationSize( size, "\pDebugTraps_PtrAndHand");

    err    = PtrAndHand( ptr, hand, size);

    if ( ! MemErrIsNormal( err ) )
        {
        AssertNoErr( err, "\p DebugTraps_PtrAndHand");
        }

    return( err );
    }



#endif // ] USE_DEBUG_TRAPS